home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / dev / lang / Python16_Src.lha / Python16_Source / Modules / _localemodule.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-08-11  |  9.1 KB  |  363 lines
  1. /***********************************************************
  2. Copyright (C) 1997 Martin von Loewis
  3.  
  4. Permission to use, copy, modify, and distribute this software and its
  5. documentation for any purpose and without fee is hereby granted,
  6. provided that the above copyright notice appear in all copies.
  7.  
  8. This software comes with no warranty. Use at your own risk.
  9. ******************************************************************/
  10.  
  11. #include "Python.h"
  12.  
  13. #include <stdio.h>
  14. #include <errno.h>
  15. #include <locale.h>
  16. #include <string.h>
  17. #include <limits.h>
  18. #include <ctype.h>
  19. #ifdef macintosh
  20. char *strdup Py_PROTO((char *));
  21. #endif
  22.  
  23. static char locale__doc__[]="Support for POSIX locales.";
  24.  
  25. static PyObject *Error;
  26.  
  27. /* support functions for formatting floating point numbers */
  28.  
  29. static char setlocale__doc__[]=
  30. "(integer,string=None) -> string. Activates/queries locale processing."
  31. ;
  32.  
  33. /* to record the LC_NUMERIC settings */
  34. static PyObject* grouping=0;
  35. static PyObject* thousands_sep=0;
  36. static PyObject* decimal_point=0;
  37. /* if non-null, indicates that LC_NUMERIC is different from "C" */
  38. static char* saved_numeric=0;
  39.  
  40. /* the grouping is terminated by either 0 or CHAR_MAX */
  41. static PyObject*
  42. copy_grouping(s)
  43.   char* s;
  44. {
  45.   int i;
  46.   PyObject *result,*val=0;
  47.   if(s[0]=='\0')
  48.      /* empty string: no grouping at all */
  49.      return PyList_New(0);
  50.   for(i=0;s[i]!='\0' && s[i]!=CHAR_MAX;i++)
  51.      /* nothing */;
  52.   result = PyList_New(i+1);
  53.   if(!result)return NULL;
  54.   i=-1;
  55.   do{
  56.     i++;
  57.     val=PyInt_FromLong(s[i]);
  58.     if(!val)break;
  59.     if(PyList_SetItem(result,i,val)){
  60.       Py_DECREF(val);
  61.       val=0;
  62.       break;
  63.     }
  64.   }while(s[i]!='\0' && s[i]!=CHAR_MAX);
  65.   if(!val){
  66.     Py_DECREF(result);
  67.     return NULL;
  68.   }
  69.   return result;
  70. }
  71.  
  72. static void
  73. fixup_ulcase()
  74. {
  75.   PyObject *mods,*strop,*string,*ulo;
  76.   unsigned char ul[256];
  77.   int n,c;
  78.  
  79.   /* finding sys.modules */
  80.   mods=PyImport_GetModuleDict();
  81.   if(!mods)return;
  82.   /* finding the module */
  83.   string=PyDict_GetItemString(mods,"string");
  84.   if(string)
  85.      string=PyModule_GetDict(string);
  86.   strop=PyDict_GetItemString(mods,"strop");
  87.   if(strop)
  88.      strop=PyModule_GetDict(strop);
  89.   if(!string && !strop)return;
  90.   /* create uppercase */
  91.   n = 0;
  92.   for (c = 0; c < 256; c++) {
  93.     if (isupper(c))
  94.        ul[n++] = c;
  95.   }
  96.   ulo=PyString_FromStringAndSize((const char *)ul,n);
  97.   if(!ulo)return;
  98.   if(string)
  99.      PyDict_SetItemString(string,"uppercase",ulo);
  100.   if(strop)
  101.      PyDict_SetItemString(strop,"uppercase",ulo);
  102.   Py_DECREF(ulo);
  103.   /* create lowercase */
  104.   n = 0;
  105.   for (c = 0; c < 256; c++) {
  106.     if (islower(c))
  107.        ul[n++] = c;
  108.   }
  109.   ulo=PyString_FromStringAndSize((const char *)ul,n);
  110.   if(!ulo)return;
  111.   if(string)
  112.      PyDict_SetItemString(string,"lowercase",ulo);
  113.   if(strop)
  114.      PyDict_SetItemString(strop,"lowercase",ulo);
  115.   Py_DECREF(ulo);
  116.   /* create letters */
  117.   n = 0;
  118.   for (c = 0; c < 256; c++) {
  119.     if (isalpha(c))
  120.        ul[n++] = c;
  121.   }
  122.   ulo=PyString_FromStringAndSize((const char *)ul,n);
  123.   if(!ulo)return;
  124.   if(string)
  125.      PyDict_SetItemString(string,"letters",ulo);
  126.   Py_DECREF(ulo);
  127. }
  128.   
  129.  
  130. static PyObject*
  131. PyLocale_setlocale(self,args)
  132.   PyObject *self;
  133.   PyObject *args;
  134. {
  135.   int category;
  136.   char *locale=0,*result;
  137.   PyObject *result_object;
  138.   struct lconv *lc;
  139.   if(!PyArg_ParseTuple(args,"i|z:setlocale",&category,&locale))return 0;
  140.   if(locale){
  141.     /* set locale */
  142.     result=setlocale(category,locale);
  143.     if(!result){
  144.       /* operation failed, no setting was changed */
  145.       PyErr_SetString(Error,"locale setting not supported");
  146.       return NULL;
  147.     }
  148.     result_object=PyString_FromString(result);
  149.     if(!result)return NULL;
  150.     /* record changes to LC_NUMERIC */
  151.     if(category==LC_NUMERIC || category==LC_ALL){
  152.       if(strcmp(locale,"C")==0 || strcmp(locale,"POSIX")==0){
  153.         /* user just asked for default numeric locale */
  154.         if(saved_numeric)free(saved_numeric);
  155.         saved_numeric=0;
  156.       }else{
  157.         /* remember values */
  158.         lc=localeconv();
  159.         Py_XDECREF(grouping);
  160.         grouping=copy_grouping(lc->grouping);
  161.         Py_XDECREF(thousands_sep);
  162.         thousands_sep=PyString_FromString(lc->thousands_sep);
  163.         Py_XDECREF(decimal_point);
  164.         decimal_point=PyString_FromString(lc->decimal_point);
  165.         saved_numeric = strdup(locale);
  166.  
  167.         /* restore to "C" */
  168.         setlocale(LC_NUMERIC,"C");
  169.       }
  170.     }
  171.     /* record changes to LC_CTYPE */
  172.     if(category==LC_CTYPE || category==LC_ALL)
  173.        fixup_ulcase();
  174.     /* things that got wrong up to here are ignored */
  175.     PyErr_Clear();
  176.   }else{
  177.     /* get locale */
  178.     /* restore LC_NUMERIC first, if appropriate */
  179.     if(saved_numeric)
  180.        setlocale(LC_NUMERIC,saved_numeric);
  181.     result=setlocale(category,NULL);
  182.     if(!result){
  183.       PyErr_SetString(Error,"locale query failed");
  184.       return NULL;
  185.     }
  186.     result_object=PyString_FromString(result);
  187.     /* restore back to "C" */
  188.     if(saved_numeric)
  189.        setlocale(LC_NUMERIC,"C");
  190.   }
  191.   return result_object;
  192. }
  193.  
  194. static char localeconv__doc__[]=
  195. "() -> dict. Returns numeric and monetary locale-specific parameters."
  196. ;
  197.  
  198. static PyObject*
  199. PyLocale_localeconv(self,args)
  200.   PyObject *self;
  201.   PyObject *args;
  202. {
  203.   PyObject* result;
  204.   struct lconv *l;
  205.   PyObject *x;
  206.   if(!PyArg_NoArgs(args))return 0;
  207.   result = PyDict_New();
  208.   if(!result)return 0;
  209.   /* if LC_NUMERIC is different in the C library, use saved value */
  210.   l = localeconv();
  211.   /* hopefully, the localeconv result survives the C library calls
  212.      involved herein */
  213. #define RESULT_STRING(s) \
  214.   x=PyString_FromString(l->s);if(!x)goto failed;PyDict_SetItemString(result,#s,x);Py_XDECREF(x)
  215. #define RESULT_INT(i) \
  216.   x=PyInt_FromLong(l->i);if(!x)goto failed;PyDict_SetItemString(result,#i,x);Py_XDECREF(x)
  217.  
  218.     /* Numeric information */
  219.   if(saved_numeric){
  220.     /* cannot use localeconv results */
  221.     PyDict_SetItemString(result,"decimal_point",decimal_point);
  222.     PyDict_SetItemString(result,"grouping",grouping);
  223.     PyDict_SetItemString(result,"thousands_sep",thousands_sep);
  224.   }else{
  225.     RESULT_STRING(decimal_point);
  226.     RESULT_STRING(thousands_sep);
  227.     x=copy_grouping(l->grouping);
  228.     if(!x)goto failed;
  229.     PyDict_SetItemString(result,"grouping",x);
  230.     Py_XDECREF(x);
  231.   }
  232.  
  233.   /* Monetary information */
  234.   RESULT_STRING(int_curr_symbol);
  235.   RESULT_STRING(currency_symbol);
  236.   RESULT_STRING(mon_decimal_point);
  237.   RESULT_STRING(mon_thousands_sep);
  238.   x=copy_grouping(l->mon_grouping);
  239.   if(!x)goto failed;
  240.   PyDict_SetItemString(result,"mon_grouping",x);
  241.   Py_XDECREF(x);
  242.   RESULT_STRING(positive_sign);
  243.   RESULT_STRING(negative_sign);
  244.   RESULT_INT(int_frac_digits);
  245.   RESULT_INT(frac_digits);
  246.   RESULT_INT(p_cs_precedes);
  247.   RESULT_INT(p_sep_by_space);
  248.   RESULT_INT(n_cs_precedes);
  249.   RESULT_INT(n_sep_by_space);
  250.   RESULT_INT(p_sign_posn);
  251.   RESULT_INT(n_sign_posn);
  252.  
  253.   return result;
  254.  failed:
  255.   Py_XDECREF(result);
  256.   Py_XDECREF(x);
  257.   return NULL;
  258. }
  259.  
  260. static char strcoll__doc__[]=
  261. "string,string -> int. Compares two strings according to the locale."
  262. ;
  263.  
  264. static PyObject*
  265. PyLocale_strcoll(self,args)
  266.   PyObject *self;
  267.   PyObject *args;
  268. {
  269.   char *s1,*s2;
  270.   if(!PyArg_ParseTuple(args,"ss:strcoll",&s1,&s2))
  271.      return NULL;
  272.   return PyInt_FromLong(strcoll(s1,s2));
  273. }
  274.  
  275. static char strxfrm__doc__[]=
  276. "string -> string. Returns a string that behaves for cmp locale-aware."
  277. ;
  278.  
  279. static PyObject*
  280. PyLocale_strxfrm(self,args)
  281.   PyObject* self;
  282.   PyObject* args;
  283. {
  284.   char *s,*buf;
  285.   int n1,n2;
  286.   PyObject *result;
  287.   if(!PyArg_ParseTuple(args,"s:strxfrm",&s))
  288.      return NULL;
  289.   /* assume no change in size, first */
  290.   n1=strlen(s)+1;
  291.   buf=PyMem_Malloc(n1);
  292.   if(!buf)return PyErr_NoMemory();
  293.   n2=strxfrm(buf,s,n1);
  294.   if(n2>n1){
  295.     /* more space needed */
  296.     buf=PyMem_Realloc(buf,n2);
  297.     if(!buf)return PyErr_NoMemory();
  298.     strxfrm(buf,s,n2);
  299.   }
  300.   result=PyString_FromString(buf);
  301.   PyMem_Free(buf);
  302.   return result;
  303. }
  304.  
  305. static struct PyMethodDef PyLocale_Methods[] = {
  306.   {"setlocale",(PyCFunction)PyLocale_setlocale,1,setlocale__doc__},
  307.   {"localeconv",(PyCFunction)PyLocale_localeconv,0,localeconv__doc__},
  308.   {"strcoll",(PyCFunction)PyLocale_strcoll,1,strcoll__doc__},
  309.   {"strxfrm",(PyCFunction)PyLocale_strxfrm,1,strxfrm__doc__},
  310.   {NULL, NULL}
  311. };
  312.  
  313. DL_EXPORT(void)
  314. init_locale()
  315. {
  316.   PyObject *m,*d,*x;
  317.   m=Py_InitModule("_locale",PyLocale_Methods);
  318.   d = PyModule_GetDict(m);
  319.   x=PyInt_FromLong(LC_CTYPE);
  320.   PyDict_SetItemString(d,"LC_CTYPE",x);
  321.   Py_XDECREF(x);
  322.  
  323.   x=PyInt_FromLong(LC_TIME);
  324.   PyDict_SetItemString(d,"LC_TIME",x);
  325.   Py_XDECREF(x);
  326.  
  327.   x=PyInt_FromLong(LC_COLLATE);
  328.   PyDict_SetItemString(d,"LC_COLLATE",x);
  329.   Py_XDECREF(x);
  330.  
  331.   x=PyInt_FromLong(LC_MONETARY);
  332.   PyDict_SetItemString(d,"LC_MONETARY",x);
  333.   Py_XDECREF(x);
  334.  
  335. #ifdef LC_MESSAGES
  336.   x=PyInt_FromLong(LC_MESSAGES);
  337.   PyDict_SetItemString(d,"LC_MESSAGES",x);
  338.   Py_XDECREF(x);
  339. #endif /* LC_MESSAGES */
  340.  
  341.   x=PyInt_FromLong(LC_NUMERIC);
  342.   PyDict_SetItemString(d,"LC_NUMERIC",x);
  343.   Py_XDECREF(x);
  344.  
  345.   x=PyInt_FromLong(LC_ALL);
  346.   PyDict_SetItemString(d,"LC_ALL",x);
  347.   Py_XDECREF(x);
  348.  
  349.   x=PyInt_FromLong(CHAR_MAX);
  350.   PyDict_SetItemString(d,"CHAR_MAX",x);
  351.   Py_XDECREF(x);
  352.  
  353.   Error = PyErr_NewException("locale.Error", NULL, NULL);
  354.   PyDict_SetItemString(d, "Error", Error);
  355.  
  356.   x=PyString_FromString(locale__doc__);
  357.   PyDict_SetItemString(d,"__doc__",x);
  358.   Py_XDECREF(x);
  359.  
  360.   if(PyErr_Occurred())
  361.     Py_FatalError("Can't initialize module locale");
  362. }
  363.